package com.my.adminservice.config.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.my.adminapi.config.domain.dto.ArgumentAddReqDTO;
import com.my.adminapi.config.domain.dto.ArgumentDTO;
import com.my.adminapi.config.domain.dto.ArgumentEditReqDTO;
import com.my.adminapi.config.domain.dto.ArgumentListReqDTO;
import com.my.adminapi.config.domain.vo.ArgumentVO;
import com.my.adminservice.config.domain.entity.SysArgument;
import com.my.adminservice.config.mapper.SysArgumentMapper;
import com.my.adminservice.config.service.ISysArgumentService;
import org.springframework.beans.BeanUtils;
import com.my.mycommondomain.domian.vo.BasePageVO;
import com.my.mycommondomain.exception.ServiceException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class SysArgumentServiceImpl implements ISysArgumentService {

    @Autowired
    private SysArgumentMapper sysArgumentMapper;

    @Override
    public Long add(ArgumentAddReqDTO argumentAddReqDTO) {
        //首先判断name和configKey是否存在
        LambdaQueryWrapper<SysArgument> queryWrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<SysArgument> eq = queryWrapper.eq(SysArgument::getConfigKey, argumentAddReqDTO.getConfigKey()).or().eq(SysArgument::getName, argumentAddReqDTO.getName());
        SysArgument sysArgument = sysArgumentMapper.selectOne(eq);
        if (sysArgument != null) {
            throw new ServiceException("参数已经存在");
        }
        sysArgument=new SysArgument();
        sysArgument.setConfigKey(argumentAddReqDTO.getConfigKey());
        sysArgument.setName(argumentAddReqDTO.getName());
        sysArgument.setValue(argumentAddReqDTO.getValue());
        if (StringUtils.isNotBlank(argumentAddReqDTO.getRemark())) {
            sysArgument.setRemark(argumentAddReqDTO.getRemark());
        }
        sysArgumentMapper.insert(sysArgument);
        return sysArgument.getId();
    }

    @Override
    public BasePageVO<ArgumentVO> list(ArgumentListReqDTO argumentListReqDTO) {
        //构造返回结果
        BasePageVO<ArgumentVO> basePageVO = new BasePageVO<>();
        LambdaQueryWrapper<SysArgument> queryWrapper = new LambdaQueryWrapper<>();
        if (StringUtils.isNotBlank(argumentListReqDTO.getConfigKey())) {
            queryWrapper.eq(SysArgument::getConfigKey, argumentListReqDTO.getConfigKey());
        }
        if (StringUtils.isNotBlank(argumentListReqDTO.getName())) {
            queryWrapper.like(SysArgument::getName, argumentListReqDTO.getName());
        }
        Page<SysArgument> sysArgumentPage = sysArgumentMapper.selectPage(new Page<SysArgument>(argumentListReqDTO.getPageNo().longValue(), argumentListReqDTO.getPageSize().longValue()), queryWrapper);
        basePageVO.setTotals((int) sysArgumentPage.getTotal());
        basePageVO.setTotalPages((int)(sysArgumentPage.getPages()));
        List<ArgumentVO> list = new ArrayList<>();
        for (SysArgument sysArgument : sysArgumentPage.getRecords()) {
            ArgumentVO argumentVO = new ArgumentVO();
            BeanUtils.copyProperties(sysArgument, argumentVO);
            list.add(argumentVO);
        }
        basePageVO.setList(list);
        return basePageVO;
    }

    @Override
    public Long edit(ArgumentEditReqDTO argumentEditReqDTO) {
        // 1 判断参数是否存在
        SysArgument sysArgument = sysArgumentMapper.selectOne(new LambdaQueryWrapper<SysArgument>().eq(SysArgument::getConfigKey, argumentEditReqDTO.getConfigKey()));
        if (sysArgument==null){
            throw new ServiceException("参数不存在");
        }
        if (sysArgumentMapper.selectOne(new LambdaQueryWrapper<SysArgument>()
                .eq(SysArgument::getName, argumentEditReqDTO.getName())
                .ne(SysArgument::getConfigKey, argumentEditReqDTO.getConfigKey())
        ) != null) {
            throw new ServiceException("参数名称存在冲突");
        }
        sysArgument.setName(argumentEditReqDTO.getName());
        sysArgument.setValue(argumentEditReqDTO.getValue());
        if (StringUtils.isNotBlank(sysArgument.getRemark())) {
            sysArgument.setRemark(sysArgument.getRemark());
        }
        sysArgumentMapper.updateById(sysArgument);
        return sysArgument.getId();
    }

    @Override
    public ArgumentDTO getByConfigKey(String configKey) {
        // 1 判断参数是否存在
        SysArgument sysArgument = sysArgumentMapper.selectOne(new LambdaQueryWrapper<SysArgument>().eq(SysArgument::getConfigKey, configKey));
        if (sysArgument==null){
            throw new ServiceException("参数不存在");
        }
        SysArgument sysArgument1 = sysArgumentMapper.selectOne(new LambdaQueryWrapper<SysArgument>().eq(SysArgument::getConfigKey, configKey));
        if (sysArgument1!=null){
            ArgumentDTO argumentDTO = new ArgumentDTO();
            BeanUtils.copyProperties(sysArgument1,argumentDTO);
            return argumentDTO;
        }
        return null;
    }

    @Override
    public List<ArgumentDTO> getByConfigKeys(List<String> configKeys) {
        List<SysArgument> sysArguments = sysArgumentMapper.selectList(new LambdaQueryWrapper<SysArgument>().in(SysArgument::getConfigKey, configKeys));
        if (sysArguments==null){
            return null;
        }
        List<ArgumentDTO> argumentDTOS = new ArrayList<>();
        for (SysArgument sysArgument : sysArguments) {
            ArgumentDTO argumentDTO = new ArgumentDTO();
            BeanUtils.copyProperties(sysArgument,argumentDTO);
            argumentDTOS.add(argumentDTO);
        }
        return argumentDTOS;
    }
}
